home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Browsers, Managers & Extensions / CookieSwap 0.5 / cookieswap-0.5.0-fx.xpi / components / CookieSwapProfileMgr.js
Text File  |  2007-07-22  |  53KB  |  1,186 lines
  1. //-----------------------------
  2. //interfaces we support
  3. const nsIProfile = Components.interfaces.nsIProfile;
  4. const nsISupports = Components.interfaces.nsISupports;
  5.  
  6. //class constants (obtained ID from http://extensions.roachfiend.com/cgi-bin/guid.pl)
  7. const CLASS_ID = Components.ID("{5bec83aa-b019-4ff2-8e26-ec6de45aca4b}");
  8. const CLASS_NAME = "CookieSwap Profile Manager";
  9. const CONTRACT_ID = "@cookieswap.mozdev.org/profile/manager-service;1";
  10.  
  11. const COOKIE_SWAP_COMP_DEBUG_ENABLED = false;
  12. function cookieswap_dbg(str)
  13. {
  14.    if(COOKIE_SWAP_COMP_DEBUG_ENABLED == true)
  15.   {
  16.       //To log to the javascript console (Tools->Error Console) use these lines
  17.       //var consoleService = Components.classes["@mozilla.org/consoleservice;1"]
  18.       //                           .getService(Components.interfaces.nsIConsoleService);
  19.       //consoleService.logStringMessage("[cookieswap]" + str );
  20.  
  21.       dump("[CookieSwapProfMgr]" + str + "\n");
  22.  
  23.    }
  24. }
  25.  
  26. //class constructor
  27. function CookieSwapProfileMgr() {
  28.   this._profileCount = 10;  //TODO
  29.   this._profileContainer = CookieProfileContainer_getInstance();
  30.   //Show the currently active profile as active on the UI
  31.   this._currentProfile = this._profileContainer.getActiveProfileId();
  32.  
  33. };
  34.  
  35.  
  36. //class definition
  37. CookieSwapProfileMgr.prototype = {
  38.   _currentProfile: null,
  39.   _profileCount: null,
  40.   _profileContainer: null,
  41.  
  42.   //--------------------------------------------------------
  43.   //property of nsIProfile interface (setter/getter methods)
  44.   //--------------------------------------------------------
  45.   get currentProfile() { return this._currentProfile; },
  46.   set currentProfile(aValue) { this.changeCurrentProfile(aValue); },
  47.   get profileCount() { return this._profileCount; },
  48.  
  49.   //-------------------------------
  50.   //methods of nsIProfile interface
  51.   //-------------------------------
  52.  
  53.   //----cloneProfile-----
  54.   cloneProfile: function(profName) {
  55.     cookieswap_dbg("cloneProfile " + profName + "\n");
  56.     this._profileCount = this._profileCount + 1;
  57.     return;
  58.   },
  59.  
  60.   //---createNewProfile-----
  61.   //---Only use the profName for CookieSwap
  62.   createNewProfile: function(profName, profDir, langCode, useExistingDir) {
  63.     cookieswap_dbg("Creating" + profName + "\n");
  64.   },
  65.  
  66.   //---deleteProfile-----
  67.   //---CookieSwap changes the definition of this method slightly.  If
  68.   //---  canDeleteFile is true then the profile is completely deleted and
  69.   //---  removed as a profile.  If canDeleteFile is false, then the contents
  70.   //---  (i.e. cookies) of the profile are deleted, but the profile still
  71.   //---  exists.
  72.   deleteProfile: function(profName, canDeleteFile) {
  73.     cookieswap_dbg("Deleting" + profName + "\n");
  74.     if (canDeleteFile == true)
  75.        cookieswap_dbg("Not implemented...Deleting profile and file\n");
  76.     else
  77.     {
  78.        cookieswap_dbg("Deleting cookies associated with " + profName + "\n");
  79.        var req_profile = this._profileContainer.getProfile(profName);
  80.        if (req_profile != null)
  81.        {
  82.           //Clear all cookies in the requested profile
  83.           req_profile.clearAllCookies();
  84.        }
  85.        else
  86.        {
  87.           cookieswap_dbg("Invalid profile name [" + profName + "] passed in\n");
  88.        }
  89.     }
  90.  
  91.   },
  92.  
  93.   //---getProfileList-----
  94.   getProfileList: function(obj) {
  95.     var profile_array = new Array();
  96.  
  97.     //Populate the UI with the profiles available
  98.     for(var i=0; i<this._profileContainer.getNumOfProfiles(); i++)
  99.     {
  100.        profile_array[i] = this._profileContainer.getProfileName(i);
  101.        cookieswap_dbg("Returning profile: " + profile_array[i]);
  102.     }
  103.  
  104.     obj.value = profile_array.length;
  105.  
  106.     return profile_array;
  107.   },
  108.   
  109.   //---profileExists-----
  110.   profileExists: function(profName) {
  111.      if (profName == "test")
  112.         return true;
  113.      else
  114.         return false; 
  115.   },
  116.  
  117.   //---renameProfile-----
  118.   renameProfile: function(oldProfName, newProfName) {
  119.     cookieswap_dbg("Rename from " + oldProfName + " to " + newProfName + "\n");
  120.   },
  121.   
  122.   //---shutDownCurrentProfile-----
  123.   shutDownCurrentProfile: function(type) {
  124.     cookieswap_dbg("Shutdown type= " + type + "\n");
  125.   },
  126.  
  127.   //--------------------------------------------------------------------------
  128.   //Private methods of CookieSwapProfileMgr (not part of an exposed Interface)
  129.   //--------------------------------------------------------------------------
  130.   //----notifyObserversOfSwap-----
  131.   notifyObserversOfSwap: function(profName) {
  132.      //Notify all the observers of the new profiles swapped in
  133.      Components.classes["@mozilla.org/observer-service;1"]
  134.          .getService(Components.interfaces.nsIObserverService)
  135.          .notifyObservers(null, "cookieswap_swap", profName);
  136.   },
  137.  
  138.   //----changeCurrentProfile-----
  139.   changeCurrentProfile: function(profName) {
  140.     cookieswap_dbg("changeCurrentProfile to " + profName + "\n");
  141.     this._currentProfile = profName;
  142.  
  143.    cookieswap_dbg("START switchProfile to " + profName);
  144.  
  145.    var old_profile_id = this._profileContainer.getActiveProfileId();
  146.    var new_profile_id = profName;
  147.  
  148.    //First thing to do is copy all the cookies from the browser and
  149.    //  save them to the profile being swapped out
  150.    if (old_profile_id != INVALID_PROFILE_ID)
  151.    {
  152.       cookieswap_dbg("Starting copyFromBrowser");
  153.       var old_profile = this._profileContainer.getProfile(old_profile_id);
  154.       old_profile.copyFromBrowser();
  155.    }
  156.    else
  157.    {
  158.       //The only normal case where this should happen is if the browser crashes
  159.       //  during a swap and we come up and no profiles are active.  On the next
  160.       //  first swap, the old profile will be INVALID
  161.       cookieswap_dbg("Profile out is invalid...an ERROR if not the first swap after a crash");
  162.    }
  163.  
  164.    //Next thing to do is to remove the cookies from the browser and copy
  165.    //  in all the cookies associated with the profile being swapped in.
  166.    //BUT, first ensure we set the ActiveProfileID to INVALID so that if
  167.    //  we were to crash, all our profiles will be intact in persistent
  168.    //  memory and we won't come up thinking that the cookies in the browers
  169.    //  are associated with any profile.
  170.    cookieswap_dbg("Setting to INVALID_PROFILE_ID");
  171.    this._profileContainer.setActiveProfileId(INVALID_PROFILE_ID);
  172.    this.notifyObserversOfSwap(INVALID_PROFILE_ID);
  173.  
  174.    //Remove all the browser cookies
  175.    cookieswap_dbg("removingAllCookies");
  176.    cookieswap_removeAllCookies();
  177.   
  178.    if (new_profile_id != INVALID_PROFILE_ID)
  179.    {
  180.       //Now swap in the cookies from the profile to the browser
  181.       var new_profile = this._profileContainer.getProfile(new_profile_id);
  182.  
  183.       cookieswap_dbg("Starting copyToBrowser");
  184.       new_profile.copyToBrowser();
  185.       cookieswap_dbg("Setting activeProfileID to " + new_profile_id);
  186.       this._profileContainer.setActiveProfileId(new_profile_id);
  187.       this.notifyObserversOfSwap(new_profile_id);
  188.  
  189.       cookieswap_dbg("Swap from profile " + old_profile_id + " to " + new_profile_id + " complete");
  190.    }
  191.    else
  192.    {
  193.       alert("[cookieswap] Internal error, profile in is invalid...no cookies swapped in");
  194.    }
  195.    
  196.    cookieswap_dbg("END switchProfile");
  197.   },
  198.  
  199.   //-------------------------------
  200.   //method of nsISupports interface
  201.   //-------------------------------
  202.   QueryInterface: function(aIID)
  203.   {
  204.     if (!aIID.equals(nsIProfile) &&    
  205.         !aIID.equals(nsISupports))
  206.       throw Components.results.NS_ERROR_NO_INTERFACE;
  207.     return this;
  208.   }
  209. };
  210.  
  211. //Factory definition
  212. var CookieSwapProfileMgrFactory = {
  213.   createInstance: function (aOuter, aIID)
  214.   {
  215.     cookieswap_dbg("Creation" + "\n");
  216.     if (aOuter != null)
  217.       throw Components.results.NS_ERROR_NO_AGGREGATION;
  218.     return (new CookieSwapProfileMgr()).QueryInterface(aIID);
  219.   }
  220. };
  221.  
  222. //module definition (xpcom registration)
  223. var CookieSwapProfileMgrModule = {
  224.   _firstTime: true,
  225.   registerSelf: function(aCompMgr, aFileSpec, aLocation, aType)
  226.   {
  227.     if (this._firstTime) {
  228.       this._firstTime = false;
  229.       throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
  230.     };
  231.     aCompMgr = aCompMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  232.     aCompMgr.registerFactoryLocation(CLASS_ID, CLASS_NAME, CONTRACT_ID, aFileSpec, aLocation, aType);
  233.   },
  234.  
  235.   unregisterSelf: function(aCompMgr, aLocation, aType)
  236.   {
  237.     aCompMgr = aCompMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  238.     aCompMgr.unregisterFactoryLocation(CLASS_ID, aLocation);        
  239.   },
  240.   
  241.   getClassObject: function(aCompMgr, aCID, aIID)
  242.   {
  243.     if (!aIID.equals(Components.interfaces.nsIFactory))
  244.       throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  245.  
  246.     if (aCID.equals(CLASS_ID))
  247.       return CookieSwapProfileMgrFactory;
  248.  
  249.     throw Components.results.NS_ERROR_NO_INTERFACE;
  250.   },
  251.  
  252.   canUnload: function(aCompMgr) { return true; }
  253. };
  254.  
  255. //module initialization
  256. function NSGetModule(aCompMgr, aFileSpec) { return CookieSwapProfileMgrModule; }
  257.  
  258. function cookieswap_removeAllCookies()
  259. {
  260.    var cookie_mgr = ffGetCookieManager();
  261.    cookie_mgr.removeAll();
  262.    cookieswap_dbg("All cookies removed");
  263. }
  264.  
  265. // *****************************************************************************
  266. // *                    CookieProfileContainer Class                           *
  267. // *                                                                           *
  268. // ************************** Coding Standards *********************************
  269. // *  gMyVariable     - global variable (starts with "g", then mixed case)     *
  270. // *  myVariable      - variables passed into functions                        *
  271. // *  my_variable     - local variable inside of a function                    *
  272. // *  this.myVariable - class attributes/variable (mixed case & always         *
  273. // *                    referenced with "this.")                               *
  274. // *  MyFunction      - functions are always mixed case                        *
  275. // *  MY_CONSTANT     - constants are all caps with underscores                *
  276. // *                                                                           *
  277. // *************************** Revision History ********************************
  278. // *  Name       Date       BugzID  Action                                     *
  279. // *  ---------  ---------  -----   ------                                     *
  280. // *  SteveTine  28Dec2005  12561   Initial Creation                           *
  281. // *  SteveTine  30Sep2006  15281   Dealing with difference in moveTo on Linux *
  282. // *                                                                           *
  283. // ************************* BEGIN LICENSE BLOCK *******************************
  284. // * Version: MPL 1.1                                                          *
  285. // *                                                                           *
  286. // *The contents of this file are subject to the Mozilla Public License Version*
  287. // * 1.1 (the "License"); you may not use this file except in compliance with  *
  288. // * the License. You may obtain a copy of the License at                      *
  289. // * http://www.mozilla.org/MPL/                                               *
  290. // *                                                                           *
  291. // * Software distributed under the License is distributed on an "AS IS" basis,*
  292. // * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License  *
  293. // * for the specific language governing rights and limitations under the      *
  294. // * License.                                                                  *
  295. // *                                                                           *
  296. // * The Original Code is the CookieSwap Mozilla/Firefox Extension             *
  297. // *                                                                           *
  298. // * The Initial Developer of the Original Code is                             *
  299. // * Steven Tine.                                                              *
  300. // * Portions created by the Initial Developer are Copyright (C) 2006          *
  301. // * the Initial Developer. All Rights Reserved.                               *
  302. // *                                                                           *
  303. // * Contributor(s): Steven Tine                                               *
  304. // *                                                                           *
  305. // **************************END LICENSE BLOCK**********************************
  306.  
  307. //Static instance attribute
  308. var gCookieProfileContainer_instance = null;
  309.  
  310. const INVALID_PROFILE_ID="";
  311. const INVALID_PROFILE_NUM=-1;
  312. const COOKIE_SWAP_DIR_NAME="CookieSwap";
  313. const COOKIE_SWAP_DIR_PERMISSIONS = 0700;  //The dir is user r/w/x only
  314.  
  315. const COOKIE_FILE_PREFACE="cookies_";  //All profile files start with this string
  316. const INACT_COOKIE_FILE_EXT="txt";    //Inactive profiles have this file extension
  317. const ACTV_COOKIE_FILE_EXT="tx1";     //Active profiles have this file extension
  318.  
  319. const DEF_PROFILE1_FILENAME = COOKIE_FILE_PREFACE + "Profile1" + "." + ACTV_COOKIE_FILE_EXT;
  320. const DEF_PROFILE2_FILENAME = COOKIE_FILE_PREFACE + "Profile2" + "." + INACT_COOKIE_FILE_EXT;
  321. const DEF_PROFILE3_FILENAME = COOKIE_FILE_PREFACE + "Profile3" + "." + INACT_COOKIE_FILE_EXT;
  322.  
  323. //-------------------CookieProfileContainer class def---------------------
  324. //The CookieProfileContainer class handles keeping track of where all the CookieProfiles
  325. // are stored and determining which profile is active.  
  326. // It also enables the user to add/remove profiles.
  327. //This class is a singleton, so there is only one in existance.  Use the
  328. // CookieProfileContainer_getInstance() to get the instance of the class.
  329. function CookieProfileContainer()
  330. {
  331.    //Define a debug function for the class...change true/false to turn it on/off
  332.    this.classDump=function(s){true ? cookieswap_dbg("[CookieProfileContainer]" + s) : (s)}
  333.  
  334.    //This is the way to call the debug function
  335.    this.classDump("START ctor");
  336.  
  337.    ////--TEMP HARDCODED PROFILES UNTIL PERS STORAGE FIGURED OUT--
  338.    this.profileArray = new Array();
  339.    this.activeProfileId = INVALID_PROFILE_ID;
  340.  
  341.    //This will get the directory of the current Mozilla profile.
  342.    //  We'll put the CookieSwap dir under there since Firefox's cookies.txt file
  343.    //  is stored in this profile dir.
  344.    this.profileDir = Components.classes["@mozilla.org/file/directory_service;1"]
  345.                         .getService(Components.interfaces.nsIProperties)
  346.                         .get("ProfD", Components.interfaces.nsIFile);
  347.    this.profileDir.append(COOKIE_SWAP_DIR_NAME);
  348.  
  349.    //If the CookieSwap directory doesn't exist, this is the first time that
  350.    //  the CookieSwap extension has run.  Create the directory and also
  351.    //  create the default profile files.
  352.    if( (this.profileDir.exists() != true) || (this.profileDir.isDirectory() != true) ) 
  353.    { 
  354.       this.classDump("First time CookieSwap has been run...creating " + COOKIE_SWAP_DIR_NAME);
  355.  
  356.       //Create the directory
  357.       this.profileDir.create(Components.interfaces.nsIFile.DIRECTORY_TYPE, COOKIE_SWAP_DIR_PERMISSIONS);
  358.  
  359.       //Make a few copies of the directory handle
  360.       var def_profile1 = this.profileDir.clone()
  361.       var def_profile2 = this.profileDir.clone()
  362.       var def_profile3 = this.profileDir.clone()
  363.  
  364.       //Append the filenames to the directory
  365.       def_profile1.append(DEF_PROFILE1_FILENAME);
  366.       def_profile2.append(DEF_PROFILE2_FILENAME);
  367.       def_profile3.append(DEF_PROFILE3_FILENAME);
  368.  
  369.       //Now create the default files
  370.       def_profile1.create(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, COOKIE_FILE_PERMISSIONS);
  371.       def_profile2.create(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, COOKIE_FILE_PERMISSIONS);
  372.       def_profile3.create(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, COOKIE_FILE_PERMISSIONS);
  373.    }
  374.  
  375.    //Let's enumerate through all the files in the CookieSwap directory
  376.    var files = this.profileDir.directoryEntries;
  377.    var i=0;
  378.  
  379.    this.classDump("Recursing the profileDir..." + files.hasMoreElements());
  380.  
  381.    while (files.hasMoreElements())
  382.    {
  383.       //Get the next file an QI to a nsIFile object
  384.       var curr_file = files.getNext();
  385.       curr_file.QueryInterface(Components.interfaces.nsIFile);
  386.  
  387.       //Convert to convient String
  388.       var file_name  = new String(curr_file.leafName);
  389.       this.classDump("--File located...Name=" + file_name);
  390.  
  391.       //Now split off the preface of the filename used for cookie files
  392.       var fname_split = file_name.split(COOKIE_FILE_PREFACE);
  393.       this.classDump("Num of split is " + fname_split.length);
  394.     
  395.       //If the split found the preface, then the file is likely a cookie file
  396.       if (fname_split.length > 1)
  397.       {
  398.          //Now split off the extension so we can get the extension and the profile name
  399.          //  If we find more than that, the file is not valid...likely a swap file
  400.          //  left around when someone edited the valid cookie file
  401.          var  profile_name = fname_split[1].split(".");
  402.  
  403.          //At this point, profile_name[0]=ProfileName, profile_name[1]=file extension
  404.          //  if there are more than 2 elements in the split then we don't have the
  405.          //  above scenario...not valid
  406.          if(profile_name.length == 2)
  407.          {
  408.             this.classDump("Profile #" + i + " : Name=" + profile_name[0] + ", ext=" + profile_name[1]);
  409.  
  410.             //We have a valid cookie profile file...create the CookieProfile object
  411.             this.profileArray[i] = new Object();
  412.             this.profileArray[i].profile = new CookieProfile(curr_file);
  413.             this.profileArray[i].name = profile_name[0];
  414.  
  415.             //If the file extension shows it as active, track it
  416.             if (profile_name[1] == ACTV_COOKIE_FILE_EXT)
  417.             {
  418.                this.classDump("Profile #" + i + " is active");
  419.                this.activeProfileId = this.profileArray[i].name;
  420.             }
  421.  
  422.             //Increment the valid profile counter
  423.             i++;
  424.          }
  425.       }
  426.  
  427.    }
  428.        
  429.    //This is the way to call the debug function
  430.    this.classDump("END ctor");
  431. }
  432.  
  433. //This "static" method returns the singleton instance of this class
  434. function CookieProfileContainer_getInstance()
  435. {
  436.    if (gCookieProfileContainer_instance == null)
  437.    {
  438.       //If this is the first time this method is being called, create the singleton
  439.       //  instance of the class and return it.
  440.       gCookieProfileContainer_instance = new CookieProfileContainer();
  441.    }
  442.  
  443.    return gCookieProfileContainer_instance;
  444. }
  445.  
  446. //This method returns the number of profiles that exist in this container.
  447. CookieProfileContainer.prototype.getNumOfProfiles = function()
  448. {
  449.    return(this.profileArray.length); 
  450. }
  451.  
  452. //This method returns a string that is the name of the profileID passed in.
  453. //  null is returned if the profileID is invalid.
  454. CookieProfileContainer.prototype.getProfileName = function(profileNum)
  455. {
  456.    if (profileNum < this.profileArray.length)
  457.    {
  458.       return(this.profileArray[profileNum].name);
  459.    }
  460.    else
  461.    {
  462.       this.classDump("Invalid Num (" + profileNum + ") passed in to getProfileName of " + this.profileArray.length);
  463.       return(null);
  464.    }
  465. }
  466.  
  467. //This method returns a string that is the name of the profileID passed in.
  468. //  null is returned if the profileID is invalid.
  469. CookieProfileContainer.prototype.getProfileNum = function(profileId)
  470. {
  471.    var prof_num=INVALID_PROFILE_NUM;
  472.  
  473.    if (profileId != INVALID_PROFILE_ID)
  474.    {
  475.       //Search the profileArray for the passed in ID
  476.       for(var i=0; i<this.profileArray.length; i++)
  477.       {
  478.          if (this.profileArray[i].name == profileId)
  479.             prof_num = i;   //Found the profileName
  480.       }
  481.  
  482.       //If after searching the array we still didn't find the ID...it's an error
  483.       if (prof_num == INVALID_PROFILE_NUM)
  484.       {
  485.          this.classDump("ERROR Invalid Name '" + profileId + "' passed in to getProfileNum. Len=" + this.profileArray.length);
  486.       }
  487.    }
  488.  
  489.    return(prof_num);
  490. }
  491.  
  492. //This method returns a CookieProfile class object corresponding to the profileID
  493. //  passed in.  If not profile with that profileID exists, null is returned.
  494. CookieProfileContainer.prototype.getProfile = function(profileId)
  495. {
  496.    var profile_num = this.getProfileNum(profileId);
  497.  
  498.    if (profile_num < this.profileArray.length)
  499.    {
  500.       return(this.profileArray[profile_num].profile);
  501.    }
  502.    else
  503.    {
  504.       this.classDump("Invalid ID (" + profileId + "which translated to " + profile_num + ") passed in to getProfile of " + this.profileArray.length);
  505.       return(null);
  506.    }
  507. }
  508.  
  509. //This method adds the passed in CookieProfile object passed in to the containder.
  510. //  The profile ID is returned.
  511. CookieProfileContainer.prototype.addProfile = function(profileName)
  512. {
  513.    this.classDump("--UNIMPLEMENTED METHOD---- addProfile()");//Still need to perform file operations
  514.    //The next availabe index in the array is the length
  515.    //var next_index = this.profileArray.length;
  516.  
  517.    return(INVALID_PROFILE_ID);
  518. }
  519.  
  520. CookieProfileContainer.prototype.removeProfile = function(profileId)
  521. {
  522.    this.classDump("--UNIMPLEMENTED METHOD---- removeProfile()");//Still need to perform file operations
  523.    if (profileId < this.profileArray.length)
  524.    {
  525.       var i;
  526.       var array_len = this.profileArray.length;
  527.       //In order to keep the profiles in numerical order, remove the profile
  528.       //  and shift all the other profiles up.
  529.       //[TODO] Not sure if this is the right thing to do because other classes
  530.       //  may have references to the old profileIDs....
  531.       for(i=profileId; i<(profile_len - 1); i++)
  532.       {
  533.          //One by one shift up the profiles in the array
  534.          this.profileArray[i].profile = this.profileArray[i+1].profile;
  535.          this.profileArray[i].name = this.profileArray[i+1].name;
  536.       }
  537.  
  538.       //Now null out the last entry in the array
  539.       this.profileArray[i].profile = null;
  540.       this.profileArray[i].name = null;
  541.    }
  542.    else
  543.    {
  544.       this.classDump("Invalid ID passed in to getProfile");
  545.    }
  546.  
  547.    return(this.profileArray.length);
  548. }
  549.  
  550. //Returns the profileID of the active profile
  551. CookieProfileContainer.prototype.getActiveProfileId = function()
  552. {
  553.    return(this.activeProfileId);
  554. }
  555.  
  556. //Changes the active profile to the profileID pased in.  The active profileID
  557. //  is returned.  If it doesn't match the profileId passed in, then it was
  558. //  not accepted as a valid profile to make active.
  559. CookieProfileContainer.prototype.setActiveProfileId = function(new_profile_id)
  560. {
  561.    this.classDump("START setActiveProfileId( " + new_profile_id + ")");
  562.  
  563.    var old_profile_id = this.activeProfileId;
  564.    var old_profile_num = this.getProfileNum(old_profile_id);
  565.    this.classDump("Old profile '" + old_profile_id + "' is num " + old_profile_num);
  566.  
  567.    var new_profile_num = this.getProfileNum(new_profile_id);
  568.    this.classDump("New profile '" + new_profile_id + "' is num " + new_profile_num);
  569.  
  570.    //If the currently active profile is valid, rename that profile's filename to indicate
  571.    //  that is no longer the active profile
  572.    if ((old_profile_id != INVALID_PROFILE_ID)  && (old_profile_num < this.profileArray.length))
  573.    {
  574.       this.classDump("START rename of old profile");
  575.  
  576.       var i = old_profile_num;
  577.       var fileHandle = this.profileArray[i].profile.getFileHandle();
  578.  
  579.       //Renaming to inactive filename
  580.       this.classDump("Renaming " + this.profileArray[i].name + " (old profile)");
  581.       this.profileArray[i].profile.setFileHandle(this.moveFile(fileHandle, COOKIE_FILE_PREFACE + this.profileArray[i].name + "." + INACT_COOKIE_FILE_EXT));
  582.    }
  583.  
  584.    //If the new profileID is valid, rename that profile's file to indicate that it
  585.    //  is the active profile
  586.    if ((new_profile_num != INVALID_PROFILE_NUM)  && (new_profile_num < this.profileArray.length))
  587.    {
  588.       var i = new_profile_num;  //Rename new_profile_num to a shorter var
  589.       var fileHandle = this.profileArray[i].profile.getFileHandle();
  590.          
  591.       //Renaming to active filename
  592.       this.classDump("Renaming " + this.profileArray[i].name + " (new profile)");
  593.       this.profileArray[i].profile.setFileHandle(this.moveFile(fileHandle, COOKIE_FILE_PREFACE + this.profileArray[i].name + "." + ACTV_COOKIE_FILE_EXT));
  594.    }
  595.    else
  596.    {
  597.       //The profile passed in is not valid.
  598.       //This is an error condition unless we are swapping to the INVALID_PROFILE_ID
  599.       if (new_profile_id != INVALID_PROFILE_ID)
  600.       {
  601.          this.classDump("ERROR Invalid ID '" + new_profile_id + "' passed in to setActiveProfileId");
  602.          new_profile_id = INVALID_PROFILE_ID;  //Non-valid ID passed in, make it INVALID
  603.       }
  604.    }
  605.       
  606.    this.activeProfileId = new_profile_id;
  607.    this.classDump("END setActiveProfileId( " + new_profile_id + ")");
  608.    
  609.    return(this.activeProfileId);
  610. }
  611.  
  612. CookieProfileContainer.prototype.moveFile = function(fileHandle, newFileName)
  613. {
  614.    this.classDump("---move start (from '" + fileHandle.leafName + "' to '" +  newFileName + "')---");
  615.  
  616.    //Actually rename the file to the new name
  617.    fileHandle.moveTo(null, newFileName);
  618.  
  619.    //On certain OSs (i.e. Linux), the call to moveTo does not update the fileHandle to point
  620.    //  to the new file.  In that case, update it manually
  621.    if (fileHandle.leafName != newFileName)
  622.    {
  623.       //Replace the existing filename portion of the path with the new filename portion of the path
  624.       newFilePath = fileHandle.path.replace(fileHandle.leafName, newFileName);
  625.  
  626.       this.classDump("Needing to update fileHandle on this OS from '" + fileHandle.path + "' to '" + newFilePath);
  627.  
  628.       //Create a new nsIFile object and point it to the new file
  629.       fileHandle = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
  630.       fileHandle.initWithPath(newFilePath);
  631.    }
  632.  
  633.    this.classDump("---move end---");
  634.    return(fileHandle);
  635. }
  636.  
  637. // *****************************************************************************
  638. // *                        CookieProfile Class                                *
  639. // *                                                                           *
  640. // ************************** Coding Standards *********************************
  641. // *  gMyVariable     - global variable (starts with "g", then mixed case)     *
  642. // *  myVariable      - variables passed into functions                        *
  643. // *  my_variable     - local variable inside of a function                    *
  644. // *  this.myVariable - class attributes/variable (mixed case & always         *
  645. // *                    referenced with "this.")                               *
  646. // *  MyFunction      - functions are always mixed case                        *
  647. // *  MY_CONSTANT     - constants are all caps with underscores                *
  648. // *                                                                           *
  649. // *************************** Revision History ********************************
  650. // *  Name       Date       BugzID  Action                                     *
  651. // *  ---------  ---------  -----   ------                                     *
  652. // *  SteveTine  28Dec2005  12561   Initial Creation                           *
  653. // *  SteveTine  11Jan2006  12720   Fixing the way session cookies are handled *
  654. // *  SteveTine  30Sep2006  15281   Adding setFileHandle method                *
  655. // *  SteveTine  16Jan2006  Trac9   Create cs_Cookie instead of Cookie class   *
  656. // *                                                                           *
  657. // ************************* BEGIN LICENSE BLOCK *******************************
  658. // * Version: MPL 1.1                                                          *
  659. // *                                                                           *
  660. // *The contents of this file are subject to the Mozilla Public License Version*
  661. // * 1.1 (the "License"); you may not use this file except in compliance with  *
  662. // * the License. You may obtain a copy of the License at                      *
  663. // * http://www.mozilla.org/MPL/                                               *
  664. // *                                                                           *
  665. // * Software distributed under the License is distributed on an "AS IS" basis,*
  666. // * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License  *
  667. // * for the specific language governing rights and limitations under the      *
  668. // * License.                                                                  *
  669. // *                                                                           *
  670. // * The Original Code is the CookieSwap Mozilla/Firefox Extension             *
  671. // *                                                                           *
  672. // * The Initial Developer of the Original Code is                             *
  673. // * Steven Tine.                                                              *
  674. // * Portions created by the Initial Developer are Copyright (C) 2006          *
  675. // * the Initial Developer. All Rights Reserved.                               *
  676. // *                                                                           *
  677. // * Contributor(s): Steven Tine                                               *
  678. // *                                                                           *
  679. // **************************END LICENSE BLOCK**********************************
  680.  
  681. const FLAGS_PR_RDONLY      = 0x01; //Open for reading only.
  682. const FLAGS_PR_WRONLY      = 0x02; //Open for writing only.
  683. const FLAGS_PR_RDWR        = 0x04; //Open for reading and writing.
  684. const FLAGS_PR_CREATE_FILE = 0x08; //If the file does not exist, the file is created.
  685. const FLAGS_PR_APPEND      = 0x10; //The file pointer is set to the end of the file prior to each write.
  686. const FLAGS_PR_TRUNCATE    = 0x20; //If the file exists, its length is truncated to 0.
  687. const FLAGS_PR_SYNC        = 0x40; //If set, each write will wait for both the file data and file status 
  688.                                    //  to be physically updated.
  689. const FLAGS_PR_EXCL        = 0x80; //With PR_CREATE_FILE, if the file does not exist, the file is created. 
  690.                                    //  If the file already exists, no action and NULL is returned
  691.  
  692. const COOKIE_FILE_PERMISSIONS = 0600;  //User read/write only (matches Linux cookies.txt file perm)
  693. const COOKIE_FILE_READ_FLAGS  = FLAGS_PR_RDONLY;
  694. const COOKIE_FILE_WRITE_FLAGS = FLAGS_PR_WRONLY | FLAGS_PR_CREATE_FILE | FLAGS_PR_TRUNCATE;
  695.  
  696. const CS_NEW_LINE = "\n";  //"\r\n"
  697. const COOKIE_FILE_HDR = 
  698.     "#This file was created by the CookieSwap extension...see cookieswap.mozdev.org" + CS_NEW_LINE + 
  699.     "#NOTE: if this file's extension is 'tx1' then this is an" + CS_NEW_LINE + 
  700.     "# active profile and the cookies in here are old and will be overwritten by the " +  CS_NEW_LINE + 
  701.     "# cookies being managed by the browser" + CS_NEW_LINE;
  702.  
  703. //-------------CookieProfile class definition--------------
  704. //This class abstracts the idea of how a profile is persistently stored.  This class
  705. //  also knows how to copy cookies to/from the browser.
  706. //Input: fileName - nsIFile object where the persistent info of this class is stored
  707. function CookieProfile(fileName)
  708. {
  709.    //Define a debug function for the class...change true/false to turn it on/off
  710.    this.classDump=function(s){true ? cookieswap_dbg("[CookieProfile]" + s) : (s)}
  711.  
  712.    //This is the way to call the debug function
  713.    this.classDump("START ctor");
  714.  
  715.    //--Create some attributes
  716.  
  717.    //nsIFile object identifying where the persistent info of this class is stored
  718.    this.fileName = fileName;
  719.  
  720.    //We need to keep track of if this is the first time this profile is being
  721.    //  swapped in for this running of the browser.  If the user just started
  722.    //  the browser up and they are swapping in this profile for the first time,
  723.    //  "session" cookies (one that expire at the end of the browser session) should
  724.    //  not be swapped in (they should be deleted).
  725.    //But, if the session cookies were swapped out to this profile in the same browser
  726.    //  session, then they should be swapped in also.
  727.    this.cookiesCameFromThisSession = false;
  728.  
  729.    this.classDump("END ctor");
  730. }
  731.  
  732. //Returns NsIFile
  733. CookieProfile.prototype.getFileHandle = function()
  734. {
  735.    return(this.fileName);
  736. }
  737.  
  738. //Sets the NsIFile
  739. CookieProfile.prototype.setFileHandle = function(newFile)
  740. {
  741.    this.fileName = newFile;
  742. }
  743.  
  744. CookieProfile.prototype.clearAllCookies = function()
  745. {
  746.    //To clear all the cookies in this profile, create an empty file (which
  747.    //  removes the old file) and then just close it.
  748.    var file_stream = this.getEmptyFile();
  749.    file_stream.close(); 
  750. }
  751.  
  752. CookieProfile.prototype.getEmptyFile = function()
  753. {
  754.    var file_out_stream = ffGetFileOutputStream();
  755.  
  756.    //Create an empty file that will contain the profile's cookies
  757.    this.classDump("opening " + this.fileName.leafName + " for writing");
  758.    file_out_stream.init(this.fileName, COOKIE_FILE_WRITE_FLAGS, COOKIE_FILE_PERMISSIONS, 0);
  759.  
  760.    //Write the header to the file
  761.    tmp_string = COOKIE_FILE_HDR;
  762.    file_out_stream.write(tmp_string, tmp_string.length);
  763.  
  764.    this.classDump("Header written");
  765.  
  766.    return(file_out_stream);  //It is assumed the caller will call file_out_stream.close()
  767. }
  768.  
  769. //NOTE this method will copy all the cookies in the Profile to the browser.  It
  770. //  will NOT delete the cookies currently in the browser so the caller should
  771. //  remove the browser cookies first if that is desired.
  772. CookieProfile.prototype.copyToBrowser = function()
  773. {
  774.    var istream = Components.classes["@mozilla.org/network/file-input-stream;1"]
  775.                            .createInstance(Components.interfaces.nsIFileInputStream);
  776.    var cookie_svc=ffGetCookieService();
  777.    var i=0;
  778.    var file_valid=true;
  779.    
  780.    this.classDump("Opening " + this.fileName.leafName + " file for reading");
  781.  
  782.    try
  783.    {
  784.       istream.init(this.fileName, COOKIE_FILE_READ_FLAGS, COOKIE_FILE_PERMISSIONS, 0);
  785.       this.classDump("Open, converting to nsILineInputStream");
  786.       istream.QueryInterface(Components.interfaces.nsILineInputStream);
  787.    }
  788.    catch (e)
  789.    {
  790.       this.classDump("init failed=>" + e);
  791.       file_valid=false;
  792.    }
  793.  
  794.    if (file_valid == true)
  795.    {
  796.       this.classDump("Open...reading");
  797.  
  798.       //read lines into array
  799.       var line = {};
  800.       var hasmore;
  801.    
  802.       do
  803.       {
  804.          hasmore = istream.readLine(line);
  805.          var str_line = new String(line.value);  //Convert to a more convienent String object
  806.      
  807.          //this.classDump("DataRead(" + str_line.length + ")=" + str_line);
  808.  
  809.          //Make sure there is data on the line and it is not a comment
  810.          if ((str_line.length > 0) && (str_line.charAt(0) != '#'))
  811.          {
  812.             var  curr_cookie = new cs_Cookie(str_line);
  813.         
  814.             if (curr_cookie.isValid == true)
  815.             {
  816.                //If the cookies in the profile file did not come from this session of the browser
  817.                //  and they are session cookies, then we don't want to swap them in.
  818.                if ((this.cookiesCameFromThisSession == false) && (curr_cookie.isSessionCookie() == true) )
  819.                {
  820.                   this.classDump("Excluding session cookie from swap because we are running a new" +
  821.                                  "browser session (" + curr_cookie.getCookieString() + ")" );
  822.                }
  823.                else
  824.                {
  825.                   //this.classDump("Adding cookie=" + curr_cookie.getCookieUrl().spec + "=>" + curr_cookie.getCookieString());
  826.                   cookie_svc.setCookieString(curr_cookie.getCookieUrl(), 
  827.                                              null, 
  828.                                              curr_cookie.getCookieString(), 
  829.                                              null);
  830.                   i++;  //Increment the valid cookie count
  831.                }
  832.             }
  833.             else
  834.             {
  835.                this.classDump("Non-comment line was invalid => " + str_line);
  836.             }
  837.          }
  838.       } while(hasmore);
  839.    
  840.       this.classDump("Closing");
  841.       istream.close();
  842.    }
  843.    else
  844.    {
  845.       alert("[CookieSwap] Warning, unable to locate file associated with selected profile.\n" +
  846.             "Expected filename=" + this.fileName.leafName + "\n" +
  847.             "Full path=" + this.fileName.path);
  848.       this.classDump("Unable to open " + this.fileName.path);
  849.    }
  850.  
  851.    this.classDump("Copied " + i + " cookies from the profile to the browser" );
  852.  
  853. }
  854.  
  855. //This method will copy all the cookies in the browser's memory to the
  856. // persistent storage of this profile (replacing all that were
  857. // currently in the storage)
  858. CookieProfile.prototype.copyFromBrowser = function()
  859. {
  860.    var cookie_mgr = ffGetCookieManager();
  861.    var cookie_iter = cookie_mgr.enumerator;
  862.    var curr_cookie;
  863.    var i;
  864.    var file_out_stream = this.getEmptyFile();  //Empty file to store the cookies
  865.  
  866.    for (i=0;cookie_iter.hasMoreElements();i++)
  867.    {
  868.       curr_cookie = cookie_iter.getNext();
  869.  
  870.       //Cast the cookie (sorry for the "C" term) to an nsICookie
  871.       if (curr_cookie instanceof Components.interfaces.nsICookie)
  872.       {
  873.           var tmp_string;
  874.           var tmp_cookie;
  875.    
  876.           //this.classDump("Constructing new cookie");
  877.  
  878.           //Conver the cookie to a "cs_Cookie" class so we can get the FileString
  879.           tmp_cookie = new cs_Cookie(curr_cookie);
  880.           //this.classDump("I have the new cookie");
  881.  
  882.           //Append the cookie to the global cookie store
  883.           tmp_string = tmp_cookie.getCookieFileString() + CS_NEW_LINE;
  884.           file_out_stream.write(tmp_string, tmp_string.length);
  885.  
  886.           tmp_string = tmp_cookie.getCookieUrl().spec + CS_NEW_LINE + 
  887.                        tmp_cookie.getCookieString() + CS_NEW_LINE;
  888.       }
  889.    }
  890.  
  891.    //Need to keep track that the cookies in the profile were taken from this
  892.    //  running of the browser session.  See the attribute definition for more
  893.    //  details on this.
  894.    this.cookiesCameFromThisSession = true;
  895.  
  896.    this.classDump("Copied " + i + " cookies from browser to the profile file");
  897.    file_out_stream.close();
  898. }
  899.  
  900.  
  901. // *****************************************************************************
  902. // *                           cs_Cookie Class                                 *
  903. // *                                                                           *
  904. // ************************** Coding Standards *********************************
  905. // *  gMyVariable     - global variable (starts with "g", then mixed case)     *
  906. // *  myVariable      - variables passed into functions                        *
  907. // *  my_variable     - local variable inside of a function                    *
  908. // *  this.myVariable - class attributes/variable (mixed case & always         *
  909. // *                    referenced with "this.")                               *
  910. // *  MyFunction      - functions are always mixed case                        *
  911. // *  MY_CONSTANT     - constants are all caps with underscores                *
  912. // *                                                                           *
  913. // *************************** Revision History ********************************
  914. // *  Name       Date       BugzID  Action                                     *
  915. // *  ---------  ---------  -----   ------                                     *
  916. // *  SteveTine  28Dec2005  12561   Initial Creation                           *
  917. // *  SteveTine  11Jan2006  12720   Fixing the way session cookies are handled *
  918. // *  SteveTine  16Jan2007  Trac9   Changing class name to avoid name clash    *
  919. // *                                                                           *
  920. // ************************* BEGIN LICENSE BLOCK *******************************
  921. // * Version: MPL 1.1                                                          *
  922. // *                                                                           *
  923. // *The contents of this file are subject to the Mozilla Public License Version*
  924. // * 1.1 (the "License"); you may not use this file except in compliance with  *
  925. // * the License. You may obtain a copy of the License at                      *
  926. // * http://www.mozilla.org/MPL/                                               *
  927. // *                                                                           *
  928. // * Software distributed under the License is distributed on an "AS IS" basis,*
  929. // * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License  *
  930. // * for the specific language governing rights and limitations under the      *
  931. // * License.                                                                  *
  932. // *                                                                           *
  933. // * The Original Code is the CookieSwap Mozilla/Firefox Extension             *
  934. // *                                                                           *
  935. // * The Initial Developer of the Original Code is                             *
  936. // * Steven Tine.                                                              *
  937. // * Portions created by the Initial Developer are Copyright (C) 2006          *
  938. // * the Initial Developer. All Rights Reserved.                               *
  939. // *                                                                           *
  940. // * Contributor(s): Steven Tine                                               *
  941. // *                                                                           *
  942. // **************************END LICENSE BLOCK**********************************
  943.  
  944. //The Date class takes milliseconds, while cookies are stored in seconds.  Use
  945. //  this define to convert from sec to ms.
  946. const SEC_TO_MS_MULT = 1000;
  947. const TAB_FIELD = "\t";
  948.  
  949. //-------------------cs_Cookie class def---------------------
  950. //  This file contains the definition of the "cs_Cookie" class which
  951. //  provides the ability to input a nsICookie or String consisting of a cookie
  952. //  line in a storage file.  It can then output the cookie in numerous
  953. //  styles:
  954. //  getCookieString-The string style needed by CookieService.setCookieString()
  955. //  getCookieUrl- URI used by CookieService.setCookieString()
  956. //  getCookieFileString-The string style used for storing a cookie in a file
  957. // 
  958. //"cookie" can be a NsICookie or it can be a string that corresponds
  959. //  to the cookie file string returned from a previous instance of
  960. //  this cookie's getCookieFileString() call.
  961. function cs_Cookie(cookie)   
  962. {
  963.    //Define a debug function for the class...change true/false to turn it on/off
  964.    this.classDump=function(s){true ? cookieswap_dbg("[cs_Cookie]" + s) : (s)}
  965.  
  966.    //This is the way to call the debug function
  967.    this.classDump("START cs_Cookie ctor");
  968.  
  969.    this.isValid = false;  //Init cookieValid flag to false...the code below will
  970.                                 //  change to true if it is found to be valid
  971.  
  972.    //I'm not sure how to override methods in javascript, so I'll use a run-time
  973.    //  type check to do it
  974.    if (cookie instanceof Components.interfaces.nsICookie)
  975.    {
  976.       //Fill in the attributes of the class based on the attributes of the cookie
  977.       this.expires  = cookie.expires;
  978.       this.host     = cookie.host;
  979.       this.isDomain = cookie.isDomain;
  980.       this.isSecure = cookie.isSecure;
  981.       this.name     = cookie.name;
  982.       this.path     = cookie.path;
  983.       this.policy   = cookie.policy;
  984.       this.status   = cookie.status;
  985.       this.value    = cookie.value;
  986.  
  987.       this.isValid = true;  //Looks like a good cookie...mark it as valid
  988.    }
  989.    else
  990.    {
  991.       if (cookie.charAt(0) != '#')  //Comment lines start with a "#"
  992.       {
  993.          //Cookie File string format is:
  994.          //  domain <tab> tailmatch <tab> path <tab> secure <tab> expires <tab> name <tab> value
  995.          //   [0]           [1]           [2]         [3]          [4]           [5]        [6]
  996.          var  fields=cookie.split(TAB_FIELD);
  997.  
  998.          //The split should find at least 6 fields...if not, it is not a valid string
  999.          if (fields.length >= 6)
  1000.          {
  1001.             this.host     = fields[0];
  1002.             this.path     = fields[2];
  1003.             this.isSecure = fields[3]=="TRUE" ? true : false;
  1004.             this.expires  = fields[4];
  1005.             this.isDomain = this.host.charAt(0) == '.' ? true : false;
  1006.             this.name     = fields[5];
  1007.             this.policy   = null;  //Information is not in the cookieString (I think)
  1008.             this.status   = null;  //Information is not in the cookieString (I think)
  1009.             this.value    = fields[6];
  1010.       
  1011.             this.isValid = true;  //Looks like a good cookie...mark it as valid
  1012.          }
  1013.          else
  1014.          {
  1015.             this.classDump("Cookie split length is only " + fields.length + " not 6+ in =>" + cookie);
  1016.          }
  1017.       }
  1018.    }
  1019.  
  1020.    this.classDump("END cs_Cookie ctor...cookie is " + this.isValid);
  1021. }
  1022.  
  1023. //Public Methods
  1024. //--------------cs_Cookie class methods-------------------
  1025. cs_Cookie.prototype.getCookieFileString = function()
  1026. {
  1027.    this.classDump("START getCookieFileString()");
  1028.  
  1029.    //Cookie File format is:
  1030.    //  domain <tab> tailmatch <tab> path <tab> secure <tab> expires <tab> name <tab> value
  1031.    var cookie_string;
  1032.  
  1033.    var tailmatch = this.host.charAt(0) == '.' ? "TRUE" : "FALSE";
  1034.    var is_secure = this.isSecure ? "TRUE" : "FALSE"; 
  1035.    
  1036.    cookie_string = this.host + TAB_FIELD + 
  1037.                    tailmatch + TAB_FIELD + 
  1038.                    this.path + TAB_FIELD +
  1039.                    is_secure + TAB_FIELD +
  1040.                    this.expires + TAB_FIELD +
  1041.                    this.name + TAB_FIELD +
  1042.                    this.value;
  1043.  
  1044.    this.classDump("END getCookieFileString()");
  1045.  
  1046.    return(cookie_string);
  1047. }
  1048.  
  1049. //This method returns a string that captures all the attributes of the cookie.  It is a 
  1050. //  string that can be used in the setCookieString method of the Cookie Service
  1051. cs_Cookie.prototype.getCookieString = function()
  1052. {
  1053.    this.classDump("START getCookieString()");
  1054.  
  1055.    var cookie_string;
  1056.  
  1057.    cookie_string = this.name + "=" + this.value + ";";
  1058.  
  1059.    //Domain cookies are those that start with ".", like ".google.com"
  1060.    if (this.host.charAt(0) == '.')
  1061.    {
  1062.       cookie_string = cookie_string + "domain=" + this.host + ";";
  1063.    }
  1064.  
  1065.    //Cookies with an expiration of 0 are "session cookies" that expire at the end of the
  1066.    //  session.  Leaving the "expires=" off the string will cause the browser to treat
  1067.    //  it as such.
  1068.    if (this.expires != 0)
  1069.    {
  1070.       cookie_string = cookie_string + "expires=" + (new Date(SEC_TO_MS_MULT * this.expires)) + ";";
  1071.    }
  1072.  
  1073.    cookie_string = cookie_string + "path=" + this.path + ";";
  1074.  
  1075.    if (this.isSecure == true)
  1076.    {
  1077.       cookie_string = cookie_string + "secure;";
  1078.    }
  1079.  
  1080.    this.classDump("cookie_string=>" + cookie_string + "\nEND getCookieString()");
  1081.  
  1082.    return (cookie_string);
  1083. }
  1084.  
  1085. //This method returns a nsIURI object that is the URL of the cookie
  1086. cs_Cookie.prototype.getCookieUrl = function()
  1087. {
  1088.    this.classDump("START getCookieUrl()");
  1089.    var uri = ffGetStandardUrl();
  1090.  
  1091.    //In the uri.spec, specify https if secure or http if not
  1092.    var http_proto = this.isSecure ? "https://" : "http://";
  1093.    uri.spec = http_proto + this.host + this.path;
  1094.  
  1095.    this.classDump("uri.spec=>" + uri.spec + "\nEND getCookieUrl()");
  1096.  
  1097.    return(uri);
  1098. }
  1099.  
  1100. //This method will return if the cookie is a "session" cookie (on that expires
  1101. //  at the end of the session) or not
  1102. cs_Cookie.prototype.isSessionCookie = function()
  1103. {
  1104.    //A session cookie is one with an expiration time of 0
  1105.    return(this.expires == 0 ? true : false);
  1106. }
  1107.  
  1108.  
  1109. // *****************************************************************************
  1110. // *                           ffComponents                                    *
  1111. // * This file provides functions to get easy access to the Mozilla/Firefox(ff)*
  1112. // * components (like nsICookieManager and nSICookieService)                   *
  1113. // * Obviously these functions aren't doing much work they just help to        *
  1114. // * keep the code looking cleaner in the other files.                         *
  1115. // * Ideally these would be "C" Macros but I'm not sure how to do that         *
  1116. // * in Javascript yet.                                                        *
  1117. // *                                                                           *
  1118. // ************************** Coding Standards *********************************
  1119. // *  gMyVariable     - global variable (starts with "g", then mixed case)     *
  1120. // *  myVariable      - variables passed into functions                        *
  1121. // *  my_variable     - local variable inside of a function                    *
  1122. // *  this.myVariable - class attributes/variable (mixed case & always         *
  1123. // *                    referenced with "this.")                               *
  1124. // *  MyFunction      - functions are always mixed case                        *
  1125. // *  MY_CONSTANT     - constants are all caps with underscores                *
  1126. // *                                                                           *
  1127. // *************************** Revision History ********************************
  1128. // *  Name       Date       BugzID  Action                                     *
  1129. // *  ---------  ---------  -----   ------                                     *
  1130. // *  SteveTine  2005Dec28  12561   Initial Creation                           *
  1131. // *                                                                           *
  1132. // ************************* BEGIN LICENSE BLOCK *******************************
  1133. // * Version: MPL 1.1                                                          *
  1134. // *                                                                           *
  1135. // *The contents of this file are subject to the Mozilla Public License Version*
  1136. // * 1.1 (the "License"); you may not use this file except in compliance with  *
  1137. // * the License. You may obtain a copy of the License at                      *
  1138. // * http://www.mozilla.org/MPL/                                               *
  1139. // *                                                                           *
  1140. // * Software distributed under the License is distributed on an "AS IS" basis,*
  1141. // * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License  *
  1142. // * for the specific language governing rights and limitations under the      *
  1143. // * License.                                                                  *
  1144. // *                                                                           *
  1145. // * The Original Code is the CookieSwap Mozilla/Firefox Extension             *
  1146. // *                                                                           *
  1147. // * The Initial Developer of the Original Code is                             *
  1148. // * Steven Tine.                                                              *
  1149. // * Portions created by the Initial Developer are Copyright (C) 2006          *
  1150. // * the Initial Developer. All Rights Reserved.                               *
  1151. // *                                                                           *
  1152. // * Contributor(s): Steven Tine                                               *
  1153. // *                                                                           *
  1154. // **************************END LICENSE BLOCK**********************************
  1155.  
  1156. function ffGetCookieManager()
  1157. {
  1158.    return(Components.classes["@mozilla.org/cookiemanager;1"].
  1159.                           getService(Components.interfaces.nsICookieManager));
  1160. }
  1161.  
  1162. function ffGetCookieService()
  1163. {
  1164.    return(Components.classes["@mozilla.org/cookieService;1"].
  1165.                                getService().QueryInterface(Components.interfaces.nsICookieService));
  1166.  
  1167. }
  1168.  
  1169. function ffGetStandardUrl()
  1170. {
  1171.    return(Components.classes["@mozilla.org/network/standard-url;1"].createInstance(Components.interfaces.nsIURI));
  1172. }
  1173.  
  1174. function ffGetDirectoryServiceProvider()
  1175. {
  1176.    return(Components.classes["@mozilla.org/file/directory_service;1"].createInstance(Components.interfaces.nsIDirectoryServiceProvider));
  1177. }
  1178.  
  1179. function ffGetFileOutputStream()
  1180. {
  1181.    return(Components.classes["@mozilla.org/network/file-output-stream;1"].
  1182.                               createInstance(Components.interfaces.nsIFileOutputStream));
  1183. }
  1184.  
  1185.  
  1186.